using Api.Model;
using System.Collections.Generic;
using System.Linq;

namespace Api.Dal
{
    public class MessageDAL
    {
        public static int GetCount()
        {
            using var ef = new EfDemoContext();
            // 如果 Messages 为空，返回 0
            if (!ef.Messages.Any())
            {
                return 0;
            }
            // 返回消息表中最大的 MessageId
            return ef.Messages.Max(m => m.MessageId);
        }
        
         // 拉黑blockedUserId
        public static bool BlockUser(int userId, int blockedUserId)
        {
            using var context = new EfDemoContext();
            // Ensure that the operation only proceeds if valid user IDs are provided
            if (userId <= 0 || blockedUserId <= 0)
            {
                return false; // Invalid IDs or attempting to block self
            }

            if (userId == blockedUserId || context.UserBlockList.Any(b => b.UserId == userId && b.BlockedId == blockedUserId))
            {
                return false; // 不能重复拉黑，不能拉黑自己
            }

            context.UserBlockList.Add(new UserBlockList 
            { 
                UserId = userId, 
                BlockedId = blockedUserId 
            });
            context.SaveChanges();
            return true;
        }

        // 解除拉黑
        public static bool UnblockUser(int userId, int blockedUserId)
        {
            using var context = new EfDemoContext();

            if (userId <= 0 || blockedUserId <= 0 || userId == blockedUserId)
            {
                return false; // 无效的用户 ID 或尝试解除拉黑自己
            }
            
            // 查找拉黑记录
            var blockRecord = context.UserBlockList.FirstOrDefault(b => b.UserId == userId && b.BlockedId == blockedUserId);

            if (blockRecord == null)
            {
                return false; // 拉黑记录不存在
            }

            context.UserBlockList.Remove(blockRecord);
            context.SaveChanges();
            return true;
        }

         // 检查用户是否被拉黑
        public static bool IsUserBlocked(int userId, int blockedUserId)
        {
            if (userId <= 0 || blockedUserId <= 0)
            {
                return false; // 无效的用户ID
            }
            using var context = new EfDemoContext();
            return context.UserBlockList.Any(b => b.UserId == userId && b.BlockedId == blockedUserId);
        }


        // 根据 ID 获取私信
        public static Message GetMessageById(int id)
        {
            using var ef = new EfDemoContext();
            return ef.Messages.FirstOrDefault(m => m.MessageId == id);
        }
        
        // 获取指定用户与其他用户之间的私信，并将所有未读私信标记为已读
        public static List<Message> GetMessagesBetweenUsersAndMarkAsRead(int userId, int otherUserId)
        {
            using var context = new EfDemoContext();
            
            // 获取指定用户与其他用户之间的私信
            var messages = context.Messages
                .Where(m => 
                    (m.SenderId == userId && m.ReceiverId == otherUserId) || 
                    (m.SenderId == otherUserId && m.ReceiverId == userId))
                .OrderBy(m => m.Timestamp)
                .ToList();

            // 标记所有未读私信为已读
            foreach (var message in messages)
            {
                if (!message.IsRead && message.ReceiverId == userId)
                {
                    message.IsRead = true;
                    context.Messages.Update(message);
                }
            }

            context.SaveChanges(); // 保存更改
            return messages; // 返回私信列表
        }


        // 获取私信列表
        public static List<Message> GetMessages(int userId)
        {
            using var ef = new EfDemoContext();
            return ef.Messages
                .Where(m => m.SenderId == userId || m.ReceiverId == userId)
                .OrderBy(m => m.Timestamp)
                .ToList();
        }
        
        // 查询用户间的所有私信，并按时间排列，展示用
        public static List<Message> GetMessagesBetweenUsers(int userId1, int userId2)
        {
            using var context = new EfDemoContext();
            return context.Messages
                .Where(m => 
                    (m.SenderId == userId1 && m.ReceiverId == userId2) || 
                    (m.SenderId == userId2 && m.ReceiverId == userId1))
                .OrderBy(m => m.Timestamp)
                .ToList();
        }

        // 更新私信状态为已读
        public static bool MarkMessageAsRead(int messageId)
        {
            var message = GetMessageById(messageId);
            if (message == null) return false; // 私信不存在

            using var context = new EfDemoContext();
            message.IsRead = true; // 将私信标记为已读
            context.Messages.Update(message); // 更新状态
            context.SaveChanges(); // 保存更改
            return true; // 返回成功
        }


        // 获取所有未读私信，按发送者分组
        public static List<IGrouping<int, Message>> GetAllUnreadMessagesGroupedBySender(int userId)
        {
            using var context = new EfDemoContext();

            // 获取该用户的所有未读私信，按发送者分组
            var unreadMessages = context.Messages
                .Where(m => m.ReceiverId == userId && !m.IsRead)
                .OrderBy(m => m.Timestamp)
                .GroupBy(m => m.SenderId) // 按发送者 ID 分组
                .ToList(); // 返回分组后的消息列表

            return unreadMessages; // 返回未读私信分组列表
        }
        
        

        // 根据 ID 删除私信
        public static bool DeleteMessage(int messageId)
        {
            Message message = GetMessageById(messageId);
            if (message != null)
            {
                using var ef = new EfDemoContext();
                ef.Messages.Remove(message);
                ef.SaveChanges();
                return true;
            }
            return false;
        }
        
        // 删除用户之间的所有私信，在删除好友时使用
        public static bool DeleteMessagesBetweenUsers(int userId, int otherUserId)
        {
            using var context = new EfDemoContext();

            // 查询该用户与另一个用户之间的所有私信
            var messagesToDelete = context.Messages
                .Where(m => 
                    (m.SenderId == userId && m.ReceiverId == otherUserId) || 
                    (m.SenderId == otherUserId && m.ReceiverId == userId))
                .ToList();

            if (!messagesToDelete.Any())
            {
                return false; // 如果没有找到要删除的私信，返回 false
            }

            // 删除这些私信
            context.Messages.RemoveRange(messagesToDelete);
            context.SaveChanges(); // 保存更改

            return true; // 返回成功
        }

        // 发送私信
        public static int? SendMessage(int senderId, int receiverId, string text)
        {
            if (IsUserBlocked(receiverId, senderId)) return null; // Blocked user

            if (senderId <= 0 || receiverId <= 0 || string.IsNullOrWhiteSpace(text))
            {
                return null; // 发送者或接收者无效，或内容为空
            }

            var message = new Message
            {
                SenderId = senderId,
                ReceiverId = receiverId,
                Text = text,
                Timestamp = DateTime.Now,
                IsRead = false
            };

            using var context = new EfDemoContext();
            context.Messages.Add(message); // 添加新消息
            int changes = context.SaveChanges(); // 保存更改

            return changes > 0 ? message.MessageId : (int?)null;; // 返回是否成功插入
        }

        // 撤回私信
        public static bool RevokeMessage(int messageId, int userId)
        {
            using var context = new EfDemoContext();
            var message = context.Messages.FirstOrDefault(m => m.MessageId == messageId);

            if (message == null || (message.SenderId != userId))
            {
                return false; // 消息不存在或用户不是发送者
            }

            // 检查消息是否在发送后2分钟内
            if ((DateTime.Now - message.Timestamp).TotalMinutes > 2)
            {
                return false; // 超过2分钟，无法撤回
            }

            context.Messages.Remove(message); // 撤回消息
            int changes = context.SaveChanges(); // 保存更改

            return changes > 0; // 返回是否成功撤回
        }


    }
}
